/LMAR=0/XLINE=20/FONT#0=BASL30[HAL, HE]/FONT#3=BASI30[HAL, HE]/FONT#4=BASB30/FONT#5=BDR40
␈↓ ↓H␈↓␈↓ αλSTANFORD ARTIFICIAL INTELLIGENCE LABORATORY ␈↓ 
#APRIL 1975




␈↓"∧␈↓ ↓H␈↓␈↓ α(␈↓¬An Overview of AL, A Programming System for Automation


␈↓"∧␈↓ ↓H␈↓¬␈↓ α>␈↓Raphael Finkel, Russell Taylor, Robert Bolles, Richard Paul␈↓#
*␈↓#, Jerome Feldman␈↓#
*␈↓#



␈↓"∨␈↓ ↓H␈↓␈↓ βλAL␈α is␈α∨an␈α high-level␈α programming␈α∨system␈α for␈α specification␈α∨of
␈↓ ↓H␈↓␈↓ αHmanipulatory␈αtasks␈αsuch␈αas␈αassembly␈αof␈αan␈αobject␈αfrom␈αparts.␈α AL␈αincludes␈αan
␈↓ ↓H␈↓␈↓ αHALGOL-like␈α∃source␈α∃language,␈α∃a␈α∃translator␈α∃for␈α∃converting␈α∃programs␈α∃into
␈↓ ↓H␈↓␈↓ αHrunnable␈α∞code,␈α∞and␈α∞a␈α∞runtime␈α
system␈α∞for␈α∞controlling␈α∞manipulators␈α∞and␈α
other
␈↓ ↓H␈↓␈↓ αHdevices.␈α The␈αsystem␈αincludes␈αadvanced␈αfeatures␈αfor␈αdescribing␈αthe␈αmotions␈αof
␈↓ ↓H␈↓␈↓ αHmanipulators,␈α∀for␈α∀using␈α∀sensory␈α∪information,␈α∀and␈α∀for␈α∀describing␈α∪assembly
␈↓ ↓H␈↓␈↓ αHalgorithms␈α⊗in␈α⊗terms␈α⊗of␈α∃common␈α⊗domain-specific␈α⊗primitives.␈α⊗ This␈α∃paper
␈↓ ↓H␈↓␈↓ αHdescribes␈α∀the␈α∃design␈α∀of␈α∃AL,␈α∀which␈α∃is␈α∀currently␈α∃being␈α∀implemented␈α∃as␈α∀a
␈↓ ↓H␈↓␈↓ αHsuccessor to the Stanford WAVE system.





␈↓"∨␈↓ ↓H␈↓␈↓ αλ______________________________________________________________________________________␈↓ >  
␈↓"∨␈↓ ↓H␈↓␈↓ αλ␈↓β␈↓#
*␈↓#␈α⊗Jerome␈α↔Feldman␈α⊗is␈α⊗now␈α↔at␈α⊗the␈α⊗University␈α↔of␈α⊗Rochester.␈α⊗ Lou␈α↔Paul␈α⊗is␈α⊗now␈α↔at␈α⊗the
␈↓ ↓H␈↓βStanford Research Institute.
␈↓"∨␈↓ ↓H␈↓β␈↓ αλThis␈α∪research␈α∪was␈α∪supported␈α∩in␈α∪part␈α∪by␈α∪the␈α∩National␈α∪Science␈α∪Foundation␈α∪under␈α∩contract
␈↓ ↓H␈↓βNo.␈α⊂GI-42906␈α⊂and␈α⊃in␈α⊂part␈α⊂by␈α⊂the␈α⊃Advanced␈α⊂Research␈α⊂Projects␈α⊂Agency␈α⊃of␈α⊂the␈α⊂Office␈α⊃of␈α⊂Defense
␈↓ ↓H␈↓βunder␈α⊗Contract␈α∃No.␈α⊗DAHC-15-73-C-0435.␈α⊗ The␈α∃views␈α⊗and␈α⊗conclusions␈α∃in␈α⊗this␈α⊗document␈α∃are
␈↓ ↓H␈↓βthose␈α⊗of␈α⊗the␈α⊗authors␈α⊗and␈α⊗should␈α⊗not␈α⊗be␈α⊗interpreted␈α⊗as␈α⊗necessarily␈α⊗representing␈α↔the␈α⊗official
␈↓ ↓H␈↓βpolicies, either expressed or implied, of the funding agencies.
␈↓ ↓H␈↓␈↓ εH␈↓ 
pPage 1

␈↓"∧␈↓ ↓H␈↓␈↓∧1 AN OVERVIEW OF AL␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλThis␈αshort␈αpaper␈αcannot␈αcover␈αthe␈αsubject␈αof␈αAL␈αwith␈αany␈αdepth;␈αa␈αcomplete␈αdiscussion␈αmay
␈↓ ↓H␈↓be␈α_found␈α_in␈α→␈↓βAL,␈α_A␈α_Programming␈α_System␈α→for␈α_Automation␈↓,␈α_Stanford␈α→Artificial␈α_Intelligence
␈↓ ↓H␈↓Laboratory␈α
Memo␈α
AIM-243,␈α
Stanford␈α
University␈α
Computer␈α
Science␈α
Department␈α∞Report␈α
STAN-
␈↓ ↓H␈↓CS-74-456, by the authors of this paper.


␈↓"∨␈↓ ↓H␈↓␈↓∧1.1 INTRODUCTION␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α∂development␈α∂of␈α∂robot␈α∂manipulators␈α∂such␈α∂as␈α∂the␈α∂"Unimate"␈α∂has␈α∂led␈α∂to␈α∂the␈α⊂belief␈α∂that
␈↓ ↓H␈↓these␈α
tools␈α
are␈α
in␈α
some␈α
way␈α
general-purpose␈α
devices␈α
and␈α
that␈α
they␈α
might␈α
be␈α
programmed␈α
like␈αa
␈↓ ↓H␈↓computer.␈α As␈αa␈αgeneral-purpose␈αprogrammable␈αdevice,␈αthe␈αrobot␈αmanipulator␈αprovides␈αa␈αpossible
␈↓ ↓H␈↓answer␈α∂to␈α∞the␈α∂need␈α∂for␈α∞automation␈α∂of␈α∞assembly␈α∂in␈α∂batch␈α∞manufacturing␈α∂industries␈α∂where␈α∞small
␈↓ ↓H␈↓production runs rule out the use of special-purpose equipment.
␈↓"∨␈↓ ↓H␈↓␈↓ αλWe␈α∞are␈α
implementing␈α∞a␈α∞system␈α
called␈α∞AL␈α
for␈α∞small␈α∞scale␈α
batch␈α∞manufacturing␈α∞where␈α
setup
␈↓ ↓H␈↓time␈α
is␈αthe␈α
key␈αfactor.␈α
We␈αrely␈α
on␈α
a␈αsymbolic␈α
database␈αand␈α
previously-defined␈αassembly␈α
primitives
␈↓ ↓H␈↓to␈α⊃minimize␈α⊂programming␈α⊃time.␈α⊂The␈α⊃system␈α⊃is␈α⊂capable␈α⊃of␈α⊂high-level␈α⊃planning␈α⊃and␈α⊂intelligent
␈↓ ↓H␈↓interpretation␈α⊂of␈α⊂user␈α⊂defined␈α⊂primitives.␈α∂The␈α⊂principal␈α⊂aim␈α⊂of␈α⊂this␈α∂work␈α⊂is␈α⊂not␈α⊂to␈α⊂provide␈α∂a
␈↓ ↓H␈↓factory␈α⊃floor␈α∩programming␈α⊃system␈α∩but␈α⊃rather␈α∩to␈α⊃design␈α∩a␈α⊃language␈α∩which␈α⊃will␈α∩be␈α⊃a␈α∩tool␈α⊃for
␈↓ ↓H␈↓investigating␈α∂the␈α∞difficulty,␈α∂necessary␈α∂programming␈α∞time,␈α∂and␈α∂feasibility␈α∞of␈α∂writing␈α∂programs␈α∞to
␈↓ ↓H␈↓control assembly operations.


␈↓"∨␈↓ ↓H␈↓␈↓∧1.2 PHILOSOPHY OF DESIGN ␈↓


␈↓"∨␈↓ ↓H␈↓␈↓βDATA AND CONTROL STRUCTURES␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α∞principal␈α∞mode␈α∂of␈α∞input␈α∞to␈α∞AL␈α∂is␈α∞textual,␈α∞as␈α∞opposed␈α∂to␈α∞spoken␈α∞or␈α∂manual␈α∞(joystick).
␈↓ ↓H␈↓There␈α∞are␈α
levels␈α∞of␈α∞complexity␈α
which␈α∞are␈α∞much␈α
more␈α∞readily␈α∞transmitted␈α
from␈α∞man␈α∞to␈α
machine
␈↓ ↓H␈↓through␈α⊃an␈α∩interface␈α⊃of␈α∩symbolic␈α⊃text.␈α∩ For␈α⊃example,␈α∩simultaneous␈α⊃motions␈α∩of␈α⊃two␈α∩arms␈α⊃and
␈↓ ↓H␈↓termination␈α⊃and␈α⊃error␈α⊂conditions␈α⊃are␈α⊃more␈α⊂likely␈α⊃to␈α⊃be␈α⊂unambiguously␈α⊃described␈α⊃through␈α⊂the
␈↓ ↓H␈↓medium␈αof␈αtext␈αbecause␈αa␈αtextual␈αlanguage␈αcan␈αprovide␈αa␈αconsistent␈αframework␈αfor␈αsuch␈αintuitive
␈↓ ↓H␈↓Page 2␈↓ ∧⎇PHILOSOPHY OF DESIGN ␈↓ ∂1.2.1

␈↓"∧␈↓ ↓H␈↓ideas.␈α Non-textual␈αforms␈αof␈αinput␈αfor␈αdefining␈αtarget␈αlocations␈αand␈αsuggesting␈αarm␈αtrajectories␈αto
␈↓ ↓H␈↓avoid␈αcollisions␈αare␈αmost␈αuseful␈αwhen␈αapplied␈αin␈αconjunction␈αwith␈αa␈αprogram␈αtext␈αwhich␈αsupplies
␈↓ ↓H␈↓the␈α⊂overall␈α∂intent␈α⊂of␈α⊂the␈α∂programmer.␈α⊂ The␈α∂supervisor␈α⊂level␈α⊂of␈α∂AL␈α⊂is␈α∂simple␈α⊂enough␈α⊂to␈α∂allow
␈↓ ↓H␈↓natural␈α∞teaching␈α∞by␈α∂showing;␈α∞it␈α∞should␈α∞be␈α∂easy␈α∞to␈α∞interface␈α∞such␈α∂devices␈α∞as␈α∞joysticks␈α∂and␈α∞vocal
␈↓ ↓H␈↓input into AL, although we do not intend to do so at present.
␈↓"∨␈↓ ↓H␈↓␈↓ αλExperience␈α
with␈α
languages␈α
like␈α
SAIL␈α
and␈α
WAVE␈α
has␈α
shown␈α
that␈α
text␈α
macros␈α
are␈α
a␈αuseful
␈↓ ↓H␈↓feature;␈αthey␈α
reduce␈αthe␈α
amount␈αof␈α
repetitive␈αtyping.␈α
 AL␈αhas␈α
a␈αgeneral-purpose␈α
text␈αmacro␈α
system
␈↓ ↓H␈↓interfaced into the scanner and parser.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α
datatypes␈α
available␈α
include␈α
those␈α∞types␈α
necessary␈α
to␈α
refer␈α
to␈α∞one-dimensional␈α
measures
␈↓ ↓H␈↓(like␈α∀distance,␈α∀time,␈α∃mass)␈α∀and␈α∀three-dimensional␈α∃measures␈α∀(like␈α∀directed␈α∃distance,␈α∀locations,
␈↓ ↓H␈↓orientations).␈α∞Arithmetic␈α
operators␈α∞are␈α
available␈α∞not␈α∞only␈α
for␈α∞the␈α
standard␈α∞scalar␈α∞operations␈α
like
␈↓ ↓H␈↓multiplication and addition, but also for such operations as rotation and translation.
␈↓"∨␈↓ ↓H␈↓␈↓ αλProvision␈α∞is␈α∞made␈α∞for␈α∞simultaneous␈α∞execution␈α∞of␈α∞several␈α∞processes.␈α∞ This␈α∞allows␈α∞calculation
␈↓ ↓H␈↓and␈α⊂arm␈α⊂motion␈α⊂to␈α⊃take␈α⊂place␈α⊂simultaneously;␈α⊂several␈α⊃manipulators␈α⊂can␈α⊂be␈α⊂in␈α⊃independent␈α⊂or
␈↓ ↓H␈↓coordinated motion.


␈↓"∨␈↓ ↓H␈↓␈↓βMOTION SPECIFICATIONS␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλExperience␈αwith␈αWAVE␈αhas␈αshown␈αthat␈αcalculating␈αtrajectories␈αfor␈αmanipulators␈αis␈αdesirable
␈↓ ↓H␈↓but␈αtime-consuming.␈α
Trajectory␈αcalculations,␈α
together␈αwith␈α
other␈αcalculations␈α
which␈αneed␈α
only␈αbe
␈↓ ↓H␈↓performed␈α∪once,␈α∩are␈α∪done␈α∪at␈α∩compile␈α∪time.␈α∩ This␈α∪allocation␈α∪of␈α∩effort␈α∪drastically␈α∪reduces␈α∩the
␈↓ ↓H␈↓computing␈αload␈αat␈αexecution␈αtime␈αand␈αeliminates␈αwasteful␈αrecomputation␈αevery␈αtime␈αa␈αsequence␈αof
␈↓ ↓H␈↓actions is executed.
␈↓"∨␈↓ ↓H␈↓␈↓ αλA␈α⊃wide␈α∩range␈α⊃of␈α∩exceptional␈α⊃conditions␈α∩can␈α⊃occur␈α∩during␈α⊃the␈α∩motion␈α⊃of␈α∩a␈α⊃manipulator.
␈↓ ↓H␈↓Appropriate␈α
action␈α
must␈αbe␈α
taken␈α
as␈αsoon␈α
as␈α
any␈αof␈α
these␈α
occurs,␈αfor␈α
example␈α
to␈αstart␈α
up␈α
a␈αnew
␈↓ ↓H␈↓concurrent␈α∪process␈α∩or␈α∪to␈α∩notify␈α∪the␈α∩user.␈α∪ Therefore,␈α∩AL␈α∪allows␈α∩the␈α∪flexible␈α∪specification␈α∩of
␈↓ ↓H␈↓conditions␈α
to␈α∞be␈α
monitored␈α∞during␈α
motions␈α∞(and␈α
during␈α
execution␈α∞of␈α
blocks␈α∞of␈α
code␈α∞in␈α
general),
␈↓ ↓H␈↓and what to do in the case that a tested condition occurs.
␈↓ ↓H␈↓1.2.3␈↓ ∧⎇PHILOSOPHY OF DESIGN ␈↓ 
pPage 3

␈↓"∧␈↓ ↓H␈↓␈↓βUSE OF A PLANNING MODEL␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλSince␈α∞locations␈α∞are␈α∞not␈α∞known␈α∞exactly␈α∞during␈α∞the␈α∞planning␈α∞of␈α∞a␈α∞trajectory,␈α∞there␈α∞is␈α∂a␈α∞clear
␈↓ ↓H␈↓distinction␈α∞between␈α∞planned␈α∞values␈α
and␈α∞runtime␈α∞values.␈α∞ Planned␈α
values␈α∞are␈α∞used␈α∞for␈α
trajectory
␈↓ ↓H␈↓calculation;␈αat␈αruntime,␈α
trajectories␈αare␈αmodified␈α
if␈αnecessary␈αto␈α
account␈αfor␈αany␈αdiscrepancies.␈α
The
␈↓ ↓H␈↓planned values are therefore a database on which trajectory calculations are computed.
␈↓"∨␈↓ ↓H␈↓␈↓ αλAssembly␈α
tasks␈α∞require␈α
that␈α∞one␈α
object␈α
be␈α∞affixed␈α
to␈α∞another.␈α
 We␈α
model␈α∞this␈α
by␈α∞having␈α
a
␈↓ ↓H␈↓semantic␈α
attachment␈α∞between␈α
objects.␈α∞If␈α
two␈α∞objects␈α
are␈α
affixed,␈α∞and␈α
one␈α∞moves,␈α
the␈α∞second␈α
one
␈↓ ↓H␈↓should␈α
move␈α
accordingly,␈α
that␈α
is,␈α
its␈α
planning␈α
value␈α
should␈α
be␈α
properly␈α
modified.␈α
The␈αplanning
␈↓ ↓H␈↓model␈αincludes␈αinformation␈αon␈αattachments␈αof␈αobjects.␈α The␈αaffixment␈αconcept␈αcarries␈αover␈αto␈αthe
␈↓ ↓H␈↓runtime␈αsystem,␈α
which␈αdoes␈αthe␈α
equivalent␈αmodifications␈αof␈α
the␈αactual␈αvalues.␈α
 This␈αsaves␈αthe␈α
user
␈↓ ↓H␈↓the␈α∞tedious␈α∞bookkeeping␈α∞operations␈α∞required␈α∞to␈α∞determine␈α∞where␈α∞an␈α∞object␈α∞is␈α∞after␈α∞its␈α∂base␈α∞has
␈↓ ↓H␈↓been moved.
␈↓"∨␈↓ ↓H␈↓␈↓ αλMore␈α
generally,␈α
the␈α
compiler␈α
maintains␈αa␈α
wide␈α
variety␈α
of␈α
information␈α
about␈αexpected␈α
runtime
␈↓ ↓H␈↓states.␈α∞ This␈α∞includes␈α∞information␈α∂like␈α∞the␈α∞accuracy␈α∞within␈α∂which␈α∞the␈α∞planning␈α∞value␈α∂is␈α∞known,
␈↓ ↓H␈↓how␈αheavy␈αan␈αobject␈αis,␈αhow␈α
many␈αfaces␈αit␈αhas␈αon␈αwhich␈αit␈α
can␈αrest,␈αhow␈αwide␈αthe␈αfingers␈α
of␈αan
␈↓ ↓H␈↓arm␈αshould␈αopen␈αto␈αgrasp␈αit.␈α This␈αinformation␈αmay␈αcome␈αfrom␈αseveral␈αsources,␈αincluding␈αexplicit
␈↓ ↓H␈↓assertions␈α⊂by␈α⊂the␈α⊂user␈α∂and␈α⊂built-in␈α⊂knowledge␈α⊂about␈α⊂the␈α∂system␈α⊂hardware.␈α⊂ AL␈α⊂has␈α⊂a␈α∂general
␈↓ ↓H␈↓framework for representing and using such knowledge.


␈↓"∨␈↓ ↓H␈↓␈↓βUSE OF DOMAIN-SPECIFIC KNOWLEDGE␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈αsystem␈αwill␈αeventually␈αhave␈αenough␈αdomain-specific␈αknowledge␈αto␈αallow␈αprograms␈αto␈αbe
␈↓ ↓H␈↓written␈α⊂in␈α⊂terms␈α⊂of␈α⊃common␈α⊂assembly␈α⊂operations,␈α⊂rather␈α⊃than␈α⊂exclusively␈α⊂in␈α⊂terms␈α⊃of␈α⊂detailed
␈↓ ↓H␈↓single␈α∀motions.␈α∀ At␈α∀the␈α∀simplest␈α∀level,␈α∀this␈α∀involves␈α∀a␈α∀library␈α∀of␈α∀common␈α∀assembly␈α∪macro-
␈↓ ↓H␈↓operations␈α∞that␈α∞can␈α∞be␈α∞conditionally␈α∞expanded␈α∞to␈α∞perform␈α∞particular␈α∞subtasks.␈α∞ Beyond␈α∂this,␈α∞we
␈↓ ↓H␈↓foresee␈α
an␈α
interactive␈α
system␈αthat␈α
can␈α
take␈α
a␈α
"high␈αlevel"␈α
description␈α
of␈α
an␈α
assembly␈αalgorithm␈α
and
␈↓ ↓H␈↓fill␈α∩in␈α∩many␈α∩of␈α∪the␈α∩detailed␈α∩decisions␈α∩required␈α∩to␈α∪produce␈α∩a␈α∩consistent␈α∩and␈α∪efficient␈α∩output
␈↓ ↓H␈↓program.
␈↓"∨␈↓ ↓H␈↓␈↓ αλA␈αuser␈αwill␈αbe␈α
able␈αto␈αspecify␈αdifferent␈αparts␈α
of␈αa␈αtask␈αat␈α
various␈αlevels␈αof␈αdetail.␈α The␈α
system
␈↓ ↓H␈↓is␈α∃designed␈α∀to␈α∃accept␈α∃explicit␈α∀advice␈α∃telling␈α∃exactly␈α∀how␈α∃some␈α∃particular␈α∀subtask␈α∃is␈α∃to␈α∀be
␈↓ ↓H␈↓accomplished.␈α∞This␈α∂is␈α∞especially␈α∞important␈α∂for␈α∞early␈α∞versions␈α∂of␈α∞AL,␈α∞which␈α∂are␈α∞not␈α∞likely␈α∂to␈α∞be
␈↓ ↓H␈↓very␈α⊃"smart"␈α∩and␈α⊃will␈α⊃therefore␈α∩require␈α⊃a␈α⊃fair␈α∩amount␈α⊃of␈α⊃explicit␈α∩help.␈α⊃ Other␈α⊃parts␈α∩can␈α⊃be
␈↓ ↓H␈↓Page 4␈↓ ∧⎇PHILOSOPHY OF DESIGN ␈↓ ∂1.2.4

␈↓"∧␈↓ ↓H␈↓described␈αby␈αassertions␈αwhich␈αspecify␈αprerequisites␈αand␈αeffects.␈α The␈αsystem␈αwill␈αthen␈αcomplete␈α
the
␈↓ ↓H␈↓program␈α∞incorporating␈α∞the␈α∞advice␈α∞and␈α∞satisfying␈α∞the␈α∞other␈α∞assertions.␈α∞The␈α∞system␈α∞can␈α∞show␈α∞the
␈↓ ↓H␈↓user␈α⊃how␈α∩it␈α⊃is␈α∩filling␈α⊃in␈α⊃the␈α∩details␈α⊃to␈α∩produce␈α⊃an␈α⊃output␈α∩program,␈α⊃and␈α∩why.␈α⊃ This␈α∩is␈α⊃very
␈↓ ↓H␈↓important␈αboth␈αfor␈αdebugging␈αand␈αfor␈αexplaining␈αto␈αthe␈αuser␈αany␈αrequests␈αfor␈αadvice␈αthat␈αit␈αmust
␈↓ ↓H␈↓make.


␈↓"∨␈↓ ↓H␈↓␈↓βTHE RUNTIME SYSTEM␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈αcalculation␈αof␈αtrajectories␈αis␈αtime-consuming␈αbut␈αnot␈αtime-critical;␈αservoing␈αof␈αdevices␈αis
␈↓ ↓H␈↓time-critical␈αbut␈αnot␈αespecially␈α
time-consuming.␈α Therefore,␈αthe␈αcompiler␈α
is␈αwritten␈αin␈αa␈α
high-level
␈↓ ↓H␈↓language,␈αSAIL,␈αwhich␈αruns␈αon␈αa␈αlarge␈αtimeshared␈αcomputer␈α(a␈αPDP-10)␈αand␈αthe␈αruntime␈αsystem
␈↓ ↓H␈↓is designed to run on a dedicated minicomputer (a PDP-11/45).
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α≤runtime␈α≤system␈α≠supports␈α≤simultaneous␈α≤executions␈α≠of␈α≤many␈α≤processes.␈α≠ Several
␈↓ ↓H␈↓manipulators␈α∂or␈α∂devices␈α⊂might␈α∂be␈α∂running␈α∂simultaneously,␈α⊂and␈α∂each␈α∂motor␈α∂requires␈α⊂a␈α∂separate
␈↓ ↓H␈↓process;␈α∀several␈α∀condition␈α∀monitors␈α∀might␈α∀be␈α∀active;␈α∀several␈α∀code␈α∀segments␈α∀(doing,␈α∀perhaps,
␈↓ ↓H␈↓calculations)␈α∞might␈α∂be␈α∞simultaneously␈α∞active.␈α∂ Those␈α∞processes␈α∞which␈α∂are␈α∞dealing␈α∂with␈α∞real-time
␈↓ ↓H␈↓devices␈α(joint␈αservos␈α
and␈αcondition␈αcheckers)␈α
must␈αbe␈αguaranteed␈α
service␈αat␈αregular␈α
intervals;␈αthe
␈↓ ↓H␈↓computation processes can fill in any time gaps.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α
wide␈αrange␈α
of␈α
conceivable␈αtasks␈α
implies␈α
that␈αpure␈α
hardware␈α
servoing␈αdoes␈α
not␈αin␈α
general
␈↓ ↓H␈↓suffice.␈α
 The␈αreason␈α
for␈αthis␈α
is␈α
that␈αhardware␈α
servoing␈αrestricts␈α
use␈α
to␈αone␈α
of␈αa␈α
small␈α
number␈αof
␈↓ ↓H␈↓servo␈α⊗modes␈α⊗(typically␈α↔position,␈α⊗velocity,␈α⊗or␈α↔force),␈α⊗and␈α⊗has␈α↔no␈α⊗provision␈α⊗for␈α↔motions␈α⊗of
␈↓ ↓H␈↓accommodation␈α∩or␈α∩motions␈α∩whose␈α∩modes␈α∩might␈α∩change␈α∩in␈α∩midstream␈α∩due␈α∩to␈α∩some␈α∩software-
␈↓ ↓H␈↓detectable␈α
condition.␈α
 Pure␈α
hardware␈α
servoing␈α
could␈α∞not␈α
be␈α
readily␈α
modified␈α
to␈α
account␈α∞for␈α
new
␈↓ ↓H␈↓feedback␈α⊃devices␈α∩or␈α⊃methods.␈α∩ A␈α⊃philosophy␈α∩of␈α⊃␈↓βsoftware␈α∩servoing␈↓␈α⊃has␈α∩these␈α⊃advantages:␈α∩It␈α⊃is
␈↓ ↓H␈↓possible␈αto␈α
program␈αthe␈α
manner␈αin␈α
which␈αfeedback␈α
is␈αto␈α
be␈αused,␈α
to␈αinterface␈α
new␈αtypes␈αof␈α
sensors,
␈↓ ↓H␈↓to␈αmodify␈αthe␈αservo␈αwhile␈αthe␈αarm␈αis␈αin␈αmotion,␈αto␈αsupply␈αthe␈αdriving␈αprogram␈α
with␈αinformation
␈↓ ↓H␈↓concerning␈α
the␈α
success␈α
of␈α
the␈α
motion␈α
as␈α
well␈α∞as␈α
to␈α
keep␈α
it␈α
up-to-date␈α
on␈α
the␈α
arm␈α
status.␈α∞ It␈α
also
␈↓ ↓H␈↓allows␈α∪coordination␈α∩of␈α∪several␈α∪arms,␈α∩with␈α∪one␈α∪acting␈α∩as␈α∪a␈α∪master␈α∩and␈α∪the␈α∪others␈α∩following.
␈↓ ↓H␈↓Hardware␈α∞servoing␈α∂would␈α∞not␈α∂save␈α∞computation␈α∂since␈α∞the␈α∂computer␈α∞would␈α∂need␈α∞to␈α∂perform␈α∞an
␈↓ ↓H␈↓equivalent servo calculation in order to understand what the manipulator is doing.
␈↓ ↓H␈↓1.3␈↓ ∧hGENERAL SYSTEM OUTLINE␈↓ 
pPage 5

␈↓"∧␈↓ ↓H␈↓␈↓∧1.3 GENERAL SYSTEM OUTLINE␈↓


␈↓"∨␈↓ ↓H␈↓␈↓βHARDWARE␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλCurrently␈αtwo␈αStanford␈α
Electric␈αArms,␈αbuilt␈αby␈α
Victor␈αScheinman␈α[Scheinman],␈αare␈α
available.
␈↓ ↓H␈↓They␈αare␈αcalled␈αYELLOW␈αand␈αBLUE.␈α Each␈αhas␈αsix␈αjoints␈αand␈αa␈αhand␈αthat␈αcan␈αopen␈αand␈αclose.
␈↓ ↓H␈↓The␈α
joints␈α∞are␈α
controlled␈α
by␈α∞electric␈α
motors;␈α
each␈α∞joint␈α
has␈α
both␈α∞position␈α
and␈α∞velocity␈α
feedback.
␈↓ ↓H␈↓Motor␈α
drives␈α
are␈α
sent␈αfrom␈α
the␈α
computer␈α
to␈α
the␈αarm␈α
via␈α
a␈α
digital-to-analog␈α
converter␈α(D-to-A);
␈↓ ↓H␈↓feedback␈α⊗signals␈α⊗are␈α⊗routed␈α⊗through␈α⊗an␈α⊗analog-to-digital␈α⊗converter␈α⊗(A-to-D)␈α⊗back␈α↔to␈α⊗the
␈↓ ↓H␈↓computer.
␈↓"∨␈↓ ↓H␈↓␈↓ αλVarious␈α⊂other␈α⊂devices␈α⊃are␈α⊂designed␈α⊂and␈α⊃implemented␈α⊂as␈α⊂needed.␈α⊃ We␈α⊂use␈α⊂tools,␈α⊃jigs␈α⊂and
␈↓ ↓H␈↓special␈αmarkings␈αfor␈α
several␈αpurposes:␈αto␈αrender␈α
a␈αtask␈αpossible␈α(an␈α
example␈αis␈αthe␈αarm␈α
itself),␈αto
␈↓ ↓H␈↓improve␈α∃efficiency␈α∃(a␈α∃mechanical␈α∃screwdriver),␈α∃and␈α∃to␈α∃overcome␈α∃some␈α∃of␈α∃our␈α∃sensory␈α∃and
␈↓ ↓H␈↓mechanical limitations (a screw dispenser).


␈↓"∨␈↓ ↓H␈↓␈↓βSOFTWARE␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλSee Figure 1 for a picture of the system.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α∩SUPERVISOR␈α⊃is␈α∩the␈α⊃top␈α∩level␈α⊃of␈α∩AL.␈α⊃ It␈α∩runs␈α⊃on␈α∩the␈α⊃timesharing␈α∩computer␈α⊃and
␈↓ ↓H␈↓provides␈αan␈αinterface␈αbetween␈αthe␈αuser␈αand␈αthe␈αother␈αparts␈αof␈αthe␈αsystem:␈α1)␈αlistening␈αto␈αthe␈αuser's
␈↓ ↓H␈↓console␈α
and␈α∞interpreting␈α
simple␈α
command␈α∞language␈α
input;␈α
2)␈α∞controlling␈α
the␈α
compiler,␈α∞starting␈α
it
␈↓ ↓H␈↓and␈α
relaying␈α
its␈α
error␈α
messages␈α
back␈α
to␈α
the␈α
user;␈α
3)␈α
signalling␈α
the␈α
loader␈α
when␈α
it␈α
is␈α∞necessary␈α
to
␈↓ ↓H␈↓place compiled code into the mini; 4) handling the runtime interface to the mini.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α∞USER␈α∞sits␈α
at␈α∞a␈α∞console␈α
and␈α∞makes␈α∞requests␈α
of␈α∞AL.␈α∞ These␈α
fall␈α∞into␈α∞several␈α
categories:
␈↓ ↓H␈↓compilation,␈αloading,␈αexecution␈αof␈αprograms,␈αdebugging␈αof␈αcode,␈αrequesting␈αof␈α
status␈αinformation,
␈↓ ↓H␈↓asking␈α⊂for␈α⊂immediate␈α⊂arm␈α⊂motion,␈α⊂saving␈α⊂and␈α⊂restoring␈α⊂the␈α⊂state␈α⊂of␈α⊂the␈α⊂world␈α⊂at␈α⊂safe␈α⊂points,
␈↓ ↓H␈↓requesting␈αexplanation␈αof␈αcertain␈αcompiler␈αdecisions.␈αThere␈αare␈αtwo␈αdifferent␈αconsoles␈αat␈α
which␈αa
␈↓ ↓H␈↓user␈α∞can␈α∞sit:␈α∞one␈α∞is␈α∞connected␈α∞to␈α∞the␈α∞timesharing␈α∞computer,␈α∞through␈α∞which␈α∞he␈α∞can␈α∞speak␈α∞to␈α∞the
␈↓ ↓H␈↓supervisor␈α
and␈αall␈α
the␈α
parts␈αof␈α
AL␈αresiding␈α
on␈α
the␈αtimesharing␈α
computer;␈α
the␈αother␈α
is␈αconnected␈α
to
␈↓ ↓H␈↓the mini, and through it the user can investigate the runtime system and cause modifications.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α⊃COMPILER␈α⊃reads␈α⊃AL␈α⊃programs␈α∩from␈α⊃files␈α⊃(or,␈α⊃optionally,␈α⊃directly␈α⊃from␈α∩the␈α⊃user's
␈↓ ↓H␈↓Page 6␈↓ ∧hGENERAL SYSTEM OUTLINE␈↓ ∂1.3.2
























␈↓ ↓H␈↓␈↓ εαFigure    1
␈↓ ↓H␈↓␈↓ ¬hOverall system


␈↓ ↓H␈↓console)␈α
and␈α
produces␈α
load␈α
modules.␈α
 The␈α
compiler␈α
is␈α
divided␈α
into␈α
three␈α
phases:␈α
The␈α
PARSER,
␈↓ ↓H␈↓which␈αproduces␈αparse␈α
trees␈αof␈αthe␈αprogram,␈α
the␈αEXPANDER,␈αwhich␈α
expands␈αthose␈αparse␈αtrees␈α
by
␈↓ ↓H␈↓replacing␈α#high-level␈α$primitives␈α#with␈α#low-level␈α$primitives,␈α#and␈α$the␈α#TRAJECTORY
␈↓ ↓H␈↓CALCULATOR and CODE GENERATOR, which creates the output files.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α∞LOADER␈α
takes␈α∞the␈α
load␈α∞modules␈α∞prepared␈α
by␈α∞the␈α
compiler␈α∞and␈α
enters␈α∞them␈α∞into␈α
the
␈↓ ↓H␈↓mini's␈αruntime␈αsystem.␈α Address␈αrelocation␈αand␈αlinking␈αare␈αdone␈αat␈αthis␈αtime.␈αThe␈αloader␈αalso␈αsets
␈↓ ↓H␈↓1.3.2␈↓ ∧hGENERAL SYSTEM OUTLINE␈↓ 
pPage 7

␈↓"∧␈↓ ↓H␈↓up␈αthe␈αdata␈αarea␈αin␈αthe␈αruntime␈αinterface␈αin␈αthe␈αtimesharing␈αcomputer;␈αthese␈αdata␈αinclude␈αoutput
␈↓ ↓H␈↓strings,␈α⊂procedure␈α⊂linkages,␈α⊂and␈α⊂information␈α∂necessary␈α⊂for␈α⊂diagnostic␈α⊂purposes␈α⊂during␈α∂runtime.
␈↓ ↓H␈↓Loading␈αis␈αoften␈αdone␈αin␈αa␈αpartially␈αincremental␈αfashion,␈αinstalling␈αnew␈αcode␈αfollowing␈αpreviously
␈↓ ↓H␈↓loaded code.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈αRUNTIME␈αINTERFACE,␈α
which␈αresides␈αin␈αthe␈α
timesharing␈αcomputer,␈αis␈α
charged␈αwith
␈↓ ↓H␈↓initiating␈αthe␈αmini␈αprogram,␈αfielding␈αprocedure␈αcalls␈αfrom␈αthe␈αrunning␈αprogram␈αto␈αprocedures␈αon
␈↓ ↓H␈↓the␈α∞timesharing␈α∞machine,␈α∞returning␈α
values␈α∞from␈α∞these␈α∞procedures,␈α
and␈α∞fetching␈α∞values␈α∞from␈α
the
␈↓ ↓H␈↓mini␈α⊂for␈α⊂debugging␈α⊂purposes.␈α⊂ The␈α⊂interface␈α⊂has␈α⊂the␈α⊂power␈α⊂to␈α⊂interrupt␈α⊂the␈α⊂execution␈α⊃of␈α⊂the
␈↓ ↓H␈↓program␈α
and␈αto␈α
modify␈α
the␈αstatus␈α
of␈αthe␈α
runtime␈α
system,␈αfor␈α
example,␈αby␈α
patching␈α
in␈αadditional
␈↓ ↓H␈↓programs␈αor␈αmodifying␈αthe␈αvalues␈αof␈αsome␈αvariables.␈α This␈αallows␈αthe␈αuser␈αto␈αcontrol␈αthe␈α
program
␈↓ ↓H␈↓through the timesharing computer.
␈↓"∨␈↓ ↓H␈↓␈↓ αλThe␈α∂RUNTIME␈α∞SYSTEM␈α∂is␈α∞the␈α∂set␈α∂of␈α∞programs␈α∂which␈α∞reside␈α∂in␈α∞the␈α∂mini.␈α∂ This␈α∞system
␈↓ ↓H␈↓includes␈αkernel␈αprograms␈αfor␈αtime-slice␈αcpu␈αsharing␈αand␈αprocess␈αcontrol␈αand␈αa␈αset␈α
of␈αdynamically
␈↓ ↓H␈↓created␈α⊂processes.␈α⊂ These␈α⊂are␈α⊂of␈α⊂three␈α⊂basic␈α⊂types:␈α⊂a)␈α⊂An␈α⊂INTERPRETER␈α⊂examines␈α⊃the␈α⊂code
␈↓ ↓H␈↓prepared␈αby␈αthe␈αcompiler␈αand␈αexecutes␈α
the␈αnumeric␈αcomputations␈αrequested.␈α When␈αa␈αmove␈α
is␈αto
␈↓ ↓H␈↓be␈α⊃started,␈α⊃the␈α⊃interpreter␈α⊃creates␈α⊂a␈α⊃servo␈α⊃for␈α⊃each␈α⊃joint␈α⊂and␈α⊃waits␈α⊃until␈α⊃all␈α⊃these␈α⊃servos␈α⊂are
␈↓ ↓H␈↓finished.␈α
 b)␈α
A␈α
SERVO␈α
handles␈α
the␈α
motion␈α
of␈α
one␈α
moving␈α
joint.␈α
c)␈α
A␈α
CONDITION-MONITOR
␈↓ ↓H␈↓repeatedly␈α⊂examines␈α⊂certain␈α⊃conditions␈α⊂(whatever␈α⊂the␈α⊂programmer␈α⊃has␈α⊂specified).␈α⊂ If␈α⊃it␈α⊂should
␈↓ ↓H␈↓discover␈αthat␈αits␈αcondition␈αhas␈αoccurred,␈αit␈αcreates␈αan␈αinterpreter␈αto␈αtake␈αappropriate␈αaction.␈α The
␈↓ ↓H␈↓runtime␈α∪system␈α∀also␈α∪includes␈α∀routines␈α∪for␈α∪communication␈α∀with␈α∪the␈α∀runtime␈α∪interface␈α∀in␈α∪the
␈↓ ↓H␈↓timesharing computer.


␈↓"∨␈↓ ↓H␈↓␈↓∧2 AN EXAMPLE␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλA␈αsimple␈αtask␈α
dealing␈αwith␈αthe␈α
objects␈αshown␈αin␈α
Figure␈α2␈αillustrates␈α
some␈αof␈αthe␈α
features␈αof
␈↓ ↓H␈↓AL:
␈↓ ↓H␈↓␈↓ αh1.␈α Pick␈αup␈αthe␈αbracket␈αwith␈αthe␈αYELLOW␈αarm␈αand␈αposition␈αit␈αnext␈αto␈αthe␈α
beam␈αso
␈↓ ↓H␈↓␈↓ αhthat the holes line up,
␈↓ ↓H␈↓␈↓ αh2.  Pick up the bolt with the BLUE arm,
␈↓ ↓H␈↓␈↓ αh3.  Fasten the bracket to the beam by inserting the bolt in the holes,
␈↓ ↓H␈↓␈↓ αh4.  Return the arms to their park positions.
␈↓"∨␈↓ ↓H␈↓␈↓ αλSome␈α
of␈α
the␈α
features␈α
to␈α
be␈α
demonstrated␈α
are:␈α
the␈α
affix␈α
structure,␈α
reference␈α
frames,␈α
dimensions,
␈↓ ↓H␈↓Page 8␈↓ εH␈↓ H
























␈↓ ↓H␈↓␈↓ εαFigure    2
␈↓ ↓H␈↓␈↓ ¬ELayout for Example


␈↓ ↓H␈↓and␈α
multi-processing.␈α∞ We␈α
demonstrate␈α∞these␈α
capabilities␈α∞by␈α
presenting␈α∞a␈α
highly␈α∞commented␈α
AL
␈↓ ↓H␈↓program␈αto␈α
accomplish␈αthe␈α
task␈αstated␈α
above.␈αExcept␈α
for␈αthe␈α
missing␈αmacro␈α
bodies␈αthis␈αprogram␈α
is
␈↓ ↓H␈↓complete; it could perform as indicated.
␈↓"∨␈↓ ↓H␈↓␈↓ αλAL␈α⊃is␈α⊃a␈α∩multi-level␈α⊃programming␈α⊃language;␈α∩at␈α⊃one␈α⊃extreme␈α∩the␈α⊃user␈α⊃can␈α∩write␈α⊃detailed,
␈↓ ↓H␈↓system-like␈αprograms␈αand␈αat␈αthe␈αother␈αhe␈αcan␈αdescribe␈αthe␈αtasks␈αand␈αany␈αpartial␈αordering␈αamong
␈↓ ↓H␈↓␈↓ εH␈↓ 
pPage 9

␈↓"∧␈↓ ↓H␈↓them␈α
and␈α
let␈α
the␈α
system␈α
determine␈α
necessary␈α
details.␈α
 Our␈α
example␈α
is␈α
written␈α
in␈α
an␈α
intermediate
␈↓ ↓H␈↓level.␈α In␈αparticular,␈αit␈αassumes␈αthat␈αthere␈αare␈αseveral␈αgeneral-purpose␈αmacros␈αand␈αroutines␈αwhich
␈↓ ↓H␈↓understand␈α
how␈α
to␈α
GRASP␈αand␈α
RELEASE␈α
things␈α
and␈αcarry␈α
out␈α
a␈α
NORMAL_SEARCH␈αto␈α
insert
␈↓ ↓H␈↓something into a hole.
␈↓"∨␈↓ ↓H␈↓␈↓ αλCapitalized␈α∂words␈α∞in␈α∂the␈α∂example␈α∞are␈α∂key␈α∂words␈α∞within␈α∂AL.␈α∂ Lower␈α∞case␈α∂words␈α∂are␈α∞user-
␈↓ ↓H␈↓defined identifiers.  Comments are surrounded by curly brackets.
␈↓ ↓H␈↓whole_task: BEGIN
␈↓ ↓H␈↓␈↓ αλ␈↓β{First␈α↔declare␈α⊗the␈α↔necessary␈α⊗FRAMEs␈α↔and␈α↔describe␈α⊗how␈α↔they␈α⊗are␈α↔initially␈α↔related.␈α⊗ A
␈↓ ↓H␈↓β␈↓ αλFRAME␈α∃is␈α∃a␈α∀coordinate␈α∃system.␈α∃ It␈α∃has␈α∀two␈α∃components:␈α∃the␈α∀location␈α∃of␈α∃the␈α∃origin␈α∀(a
␈↓ ↓H␈↓β␈↓ αλdistance␈α⊃VECTOR)␈α⊃and␈α∩the␈α⊃orientation␈α⊃of␈α∩the␈α⊃axes␈α⊃(a␈α∩ROT).␈α⊃ Frames␈α⊃are␈α∩typically␈α⊃used
␈↓ ↓H␈↓β␈↓ αλto␈α⊂describe␈α⊃objects␈α⊂and␈α⊃important␈α⊂features␈α⊂of␈α⊃objects.␈α⊂ There␈α⊃are␈α⊂several␈α⊃predeclared␈α⊂frames
␈↓ ↓H␈↓β␈↓ αλin␈α∪AL.␈α∪ STATION␈α∀is␈α∪the␈α∪frame␈α∀which␈α∪represents␈α∪the␈α∀work␈α∪station's␈α∪frame␈α∀of␈α∪reference.
␈↓ ↓H␈↓β␈↓ αλEach␈α∃hand␈α∃available␈α∃to␈α∃the␈α∃system␈α∀also␈α∃has␈α∃a␈α∃frame␈α∃variable,␈α∃whose␈α∃value␈α∀(continually
␈↓ ↓H␈↓β␈↓ αλupdated)␈α∪is␈α∪the␈α∪position␈α∀of␈α∪that␈α∪hand.␈α∪ Currently␈α∀there␈α∪are␈α∪two␈α∪such␈α∀frames:␈α∪YELLOW
␈↓ ↓H␈↓β␈↓ αλand BLUE.
␈↓ ↓H␈↓β␈↓ αλThe␈α∀attach␈α∀structure␈α∀representing␈α∀the␈α∀initial␈α∀world␈α∀is␈α∀shown␈α∀in␈α∀Figure␈α∀3.␈α∀ The␈α∪arrows
␈↓ ↓H␈↓β␈↓ αλindicate␈α⊂how␈α⊂the␈α⊂movement␈α⊃of␈α⊂a␈α⊂frame␈α⊂affects␈α⊃other␈α⊂frames.␈α⊂ If␈α⊂a␈α⊃frame␈α⊂at␈α⊂the␈α⊂tail␈α⊃of␈α⊂an
␈↓ ↓H␈↓β␈↓ αλarrow␈α∪is␈α∪moved␈α∪(by␈α∩the␈α∪arm,␈α∪visually␈α∪updated,␈α∩etc.)␈α∪the␈α∪frame␈α∪at␈α∩the␈α∪head␈α∪of␈α∪the␈α∩arrow
␈↓ ↓H␈↓β␈↓ αλwill␈α⊃be␈α⊃automatically␈α⊃updated.␈α⊃ The␈α⊃double␈α⊂arrows␈α⊃are␈α⊃the␈α⊃results␈α⊃of␈α⊃RIGIDLY␈α⊂AFFIXing
␈↓ ↓H␈↓β␈↓ αλone frame to another.}
␈↓ ↓H␈↓FRAME beam, beam_hole;          FRAME bolt;
␈↓ ↓H␈↓FRAME bracket, bracket_hole, bracket_grasp;
␈↓ ↓H␈↓beam ← FRAME(ROT(Z, 90*DEG), VECTOR(10,6,0));
␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α∩beam␈α∩is␈α∩expected␈α∩to␈α∩be␈α∩positioned␈α∩at␈α∩(10,6,0)␈α∩in␈α∩the␈α∩station's␈α∩coordinate␈α∩system␈α∩(the
␈↓ ↓H␈↓β␈↓ αλdefault␈α∪unit␈α∪for␈α∪distance␈α∩measurements␈α∪is␈α∪centimeters)␈α∪and␈α∩rotated␈α∪90␈α∪degrees␈α∪about␈α∩the
␈↓ ↓H␈↓β␈↓ αλstation's␈α∀Z␈α∀vector.␈α∀ AL␈α∪knows␈α∀about␈α∀dimensions␈α∀like␈α∪DEG␈α∀for␈α∀degrees.␈α∀ Dimensions␈α∪are
␈↓ ↓H␈↓β␈↓ αλadjuncts to variable types; new ones can be defined in terms of old ones.}
␈↓ ↓H␈↓beam_hole ← beam*TRANS(ROT(X, 90*DEG), VECTOR(3,0,7));
␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α∃TRANS␈α∃represents␈α∃the␈α∀position␈α∃of␈α∃the␈α∃beam_hole␈α∀with␈α∃respect␈α∃to␈α∃the␈α∃beam.␈α∀ The
␈↓ ↓H␈↓β␈↓ αλpremultiplication␈α∃by␈α∃the␈α⊗frame␈α∃beam␈α∃positions␈α∃the␈α⊗beam_hole␈α∃in␈α∃the␈α⊗station's␈α∃coordinate
␈↓ ↓H␈↓β␈↓ αλsystem.}
␈↓ ↓H␈↓AFFIX beam_hole TO beam; ␈↓β{As shown in Figure 3}␈↓
␈↓ ↓H␈↓ASSERT FORM(DEPROACH, beam_hole, TRANS(NILROT,VECTOR(0,0,-3));
␈↓ ↓H␈↓Page 10␈↓ εH␈↓ H

␈↓"∧␈↓ ↓H␈↓␈↓ αλ␈↓β{Trajectories␈α↔consist␈α_of␈α↔a␈α↔path␈α_from␈α↔the␈α↔current␈α_position,␈α↔through␈α↔a␈α_departure␈α↔point,
␈↓ ↓H␈↓β␈↓ αλpossibly␈α≤through␈α≤some␈α≤via␈α≤points,␈α≤through␈α≠an␈α≤approach␈α≤point,␈α≤and␈α≤finally␈α≤to␈α≠the
␈↓ ↓H␈↓β␈↓ αλdestination.␈α⊃ The␈α⊃primary␈α⊃use␈α⊃of␈α⊃via␈α∩points␈α⊃is␈α⊃to␈α⊃avoid␈α⊃collisions␈α⊃during␈α⊃the␈α∩motion.␈α⊃ All
␈↓ ↓H␈↓β␈↓ αλFRAMEs␈α∪have␈α∪a␈α∪DEPROACH␈α∪TRANS␈α∪associated␈α∪with␈α∪them.␈α∪ TRANSes␈α∪are␈α∩essentially
␈↓ ↓H␈↓β␈↓ αλthe␈α→same␈α→as␈α_FRAMEs.␈α→ Whenever␈α→leaving␈α_(or␈α→moving␈α→to)␈α_a␈α→FRAME␈α→the␈α_standard
␈↓ ↓H␈↓β␈↓ αλdeparture␈α∩(or␈α∩approach)␈α∩used␈α∩is␈α∪that␈α∩FRAME's␈α∩DEPROACH␈α∩TRANS.␈α∩ The␈α∪station␈α∩has
␈↓ ↓H␈↓β␈↓ αλa␈α→DEPROACH␈α→TRANS␈α_which␈α→is␈α→three␈α_inches␈α→above␈α→it.␈α_ Whenever␈α→one␈α→FRAME␈α_is
␈↓ ↓H␈↓β␈↓ αλAFFIXed␈α⊂to␈α⊃another,␈α⊂by␈α⊂default␈α⊃the␈α⊂former␈α⊃takes␈α⊂on␈α⊂the␈α⊃latter's␈α⊂DEPROACH.␈α⊃ The␈α⊂result
␈↓ ↓H␈↓β␈↓ αλof␈α∩this␈α∩ASSERT␈α∩is␈α∩that␈α∪the␈α∩arms␈α∩will␈α∩approach␈α∩the␈α∪beam␈α∩hole␈α∩from␈α∩the␈α∩side␈α∪instead␈α∩of
␈↓ ↓H␈↓β␈↓ αλfrom above.}
␈↓ ↓H␈↓bracket ← FRAME(ROT(Z,45*DEG),VECTOR(20,14,0));
␈↓ ↓H␈↓bracket_hole ← bracket*TRANS(ROT(X,180*DEG),VECTOR(3,3,0));
␈↓ ↓H␈↓AFFIX bracket_hole TO bracket;
␈↓ ↓H␈↓bracket_grasp ← bracket*TRANS(ROT(X,180*DEG),VECTOR(0,3,3));
␈↓ ↓H␈↓AFFIX bracket_grasp TO bracket RIGIDLY;
␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α~RIGID␈α~AFFIXment␈α~insures␈α~that␈α→a␈α~change␈α~of␈α~bracket_grasp␈α~will␈α→automatically
␈↓ ↓H␈↓β␈↓ αλchange␈α→bracket,␈α_which␈α→in␈α→turn␈α_will␈α→automatically␈α→change␈α_bracket_hole.␈α→ This␈α→is␈α_quite
␈↓ ↓H␈↓β␈↓ αλconvenient␈α∩if␈α∩the␈α∩position␈α⊃of␈α∩the␈α∩whole␈α∩`object'␈α∩is␈α⊃being␈α∩updated␈α∩by␈α∩one␈α∩grasping␈α⊃position
␈↓ ↓H␈↓β␈↓ αλ(ie. bracket_grasp).}
␈↓ ↓H␈↓bolt ← FRAME(ROT(Z,90*DEG)*ROT(X,180*DEG),VECTOR(16,30,0));
␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α⊂rotation␈α⊂portion␈α⊂of␈α⊂the␈α⊂FRAME␈α⊂has␈α⊂been␈α⊂specified␈α⊂as␈α⊂a␈α⊂composition␈α⊂of␈α⊂two␈α⊂primitive
␈↓ ↓H␈↓β␈↓ αλrotations.}
␈↓ ↓H␈↓DEFINE OZ = "72.007789*DYNES";
␈↓ ↓H␈↓DEFINE INCHES = "2.54*CM";
␈↓ ↓H␈↓␈↓ αλ␈↓β{Some of the standard macros are defined next.}
␈↓ ↓H␈↓DEFINE grasp
␈↓ ↓H␈↓       (TRANS special_departure,special_approach;
␈↓ ↓H␈↓        FRAME ATOM the_arm (DEFAULT YELLOW);
␈↓ ↓H␈↓        FRAME object,grasp_point,thing_object_affixed_to;
␈↓ ↓H␈↓        DISTANCE SCALAR opening_before_departure,
␈↓ ↓H␈↓                opening_for_approach(DEFAULT 15*CM),
␈↓ ↓H␈↓                thickness(DEFAULT 0.1*INCHES))
␈↓ ↓H␈↓        = " ␈↓β{body of macro goes here}␈↓ ";
␈↓ ↓H␈↓␈↓ εH␈↓ 
aPage 11

␈↓"∧␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α≥expansion␈α≤of␈α≥such␈α≤a␈α≥macro␈α≤can␈α≥depend␈α≤upon␈α≥the␈α≤supplied␈α≥arguments,␈α≤the
␈↓ ↓H␈↓β␈↓ αλDEFAULT arguments, and any values in the current planning model.}
␈↓ ↓H␈↓DEFINE release
␈↓ ↓H␈↓       (FRAME ATOM the_arm(DEFAULT YELLOW);
␈↓ ↓H␈↓        FRAME the_object,the_new_parent;
␈↓ ↓H␈↓        DISTANCE SCALAR the_opening(DEFAULT 15*CM))
␈↓ ↓H␈↓        = " ␈↓β{body of macro goes here}␈↓ ";
␈↓ ↓H␈↓DEFINE normal_search
␈↓ ↓H␈↓       (FRAME ATOM the_arm(DEFAULT YELLOW);
␈↓ ↓H␈↓        DISTANCE SCALAR increment(DEFAULT .3*CM), distance_fwd;
␈↓ ↓H␈↓        FORCE SCALAR stopping_force;
␈↓ ↓H␈↓        SCALAR number_of_tries(DEFAULT 9))
␈↓ ↓H␈↓        = " ␈↓β{body of macro goes here}␈↓ ";
␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α↔includes␈α⊗some␈α↔automatic␈α⊗error␈α↔recovery␈α⊗and␈α↔a␈α⊗call␈α↔to␈α⊗the␈α↔operator␈α↔if␈α⊗something
␈↓ ↓H␈↓β␈↓ αλdrastic goes wrong.}
␈↓ ↓H␈↓COBEGIN
␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α≡COBEGIN-COEND␈α∨construction␈α≡describes␈α≡two␈α∨independent␈α≡subtasks␈α∨(one␈α≡for
␈↓ ↓H␈↓β␈↓ αλYELLOW␈α∃and␈α∃one␈α⊗for␈α∃BLUE)␈α∃which␈α⊗can␈α∃be␈α∃executed␈α∃in␈α⊗any␈α∃order␈α∃determined␈α⊗by␈α∃the
␈↓ ↓H␈↓β␈↓ αλruntime␈α∩system;␈α⊃in␈α∩parallel␈α⊃or␈α∩serially.␈α⊃ This,␈α∩of␈α⊃course,␈α∩assumes␈α⊃that␈α∩the␈α⊃two␈α∩arms␈α⊃work
␈↓ ↓H␈↓β␈↓ αλin completely separate parts of the workstation so there is no possibility of a collision.}
␈↓ ↓H␈↓    ypickup: BEGIN ␈↓β{pick up the bracket with yellow}␈↓
␈↓ ↓H␈↓    grasp(object=bracket,grasp_point=bracket_grasp,opening_for_approach=3*CM);
␈↓ ↓H␈↓␈↓ αH␈↓β{Only␈α∩the␈α∩necessary␈α∩parameters␈α∩need␈α∩to␈α∩be␈α∩specified.␈α∩ By␈α∩default␈α∩the␈α∪YELLOW␈α∩arm
␈↓ ↓H␈↓β␈↓ αHwill␈α∪be␈α∪used␈α∪and␈α∪there␈α∪will␈α∪be␈α∩no␈α∪special␈α∪approaches␈α∪or␈α∪departures.␈α∪ One␈α∪effect␈α∩of
␈↓ ↓H␈↓β␈↓ αHgrasp is to AFFIX the object to the arm.}
␈↓ ↓H␈↓    MOVE bracket_hole TO beam_hole + VECTOR(0,0,-.3) WRT beam_hole;
␈↓ ↓H␈↓␈↓ αH␈↓β{The␈α∀YELLOW␈α∃arm␈α∀(since␈α∀it␈α∃holds␈α∀the␈α∀bracket␈α∃to␈α∀which␈α∀bracket_hole␈α∃is␈α∀AFFIXed)
␈↓ ↓H␈↓β␈↓ αHpositions␈α∀itself␈α∀so␈α∀that␈α∀the␈α∀bracket_hole␈α∀lines␈α∀up␈α∀with␈α∀the␈α∀beam_hole,␈α∀but␈α∀is␈α∀.3␈α∪cm
␈↓ ↓H␈↓β␈↓ αHaway␈α∃from␈α⊗the␈α∃beam_hole.␈α∃ The␈α⊗WRT␈α∃operator␈α⊗is␈α∃one␈α∃way␈α⊗of␈α∃describing␈α⊗a␈α∃vector
␈↓ ↓H␈↓β␈↓ αHwithin a frame of reference other than the station's.}
␈↓ ↓H␈↓    MOVE YELLOW TO ⊗ + VECTOR(0,0,.6) WRT beam_hole
␈↓ ↓H␈↓        ON FORCE(Z WRT beam_hole)>50*OZ DO STOP YELLOW
␈↓ ↓H␈↓        ON ARRIVAL DO ABORT("***  error   ***  bracket  went  too  far");
␈↓ ↓H␈↓Page 12␈↓ εH␈↓ H

␈↓"∧␈↓ ↓H␈↓␈↓ αH␈↓β{The␈α∃⊗␈α∃represents␈α⊗the␈α∃current␈α∃position␈α∃of␈α⊗the␈α∃arm.␈α∃ The␈α∃arm␈α⊗moves␈α∃.6␈α∃cm␈α⊗in␈α∃Z
␈↓ ↓H␈↓β␈↓ αHrelative␈α∩to␈α∩the␈α∩beam_hole's␈α∩frame.␈α∩ The␈α∩purpose␈α∩of␈α∩this␈α∩move␈α∩is␈α∩to␈α∩push␈α∩the␈α∩bracket
␈↓ ↓H␈↓β␈↓ αHup␈α∪against␈α∪the␈α∪beam.␈α∪ If␈α∪the␈α∪beam␈α∪is␈α∪there,␈α∪the␈α∪arm␈α∪will␈α∪sense␈α∪an␈α∪opposing␈α∪force.
␈↓ ↓H␈↓β␈↓ αHIf␈α∪not,␈α∀the␈α∪arm␈α∪will␈α∀succeed␈α∪in␈α∪moving␈α∀forward␈α∪the␈α∪prescribed␈α∀.6␈α∪cm.␈α∪ In␈α∀order␈α∪to
␈↓ ↓H␈↓β␈↓ αHcheck␈α→for␈α_these␈α→possibilities,␈α→two␈α_condition␈α→monitors␈α→have␈α_been␈α→included␈α→with␈α_the
␈↓ ↓H␈↓β␈↓ αHMOVE␈α∪statement.␈α∩ The␈α∪first␈α∩one␈α∪monitors␈α∪the␈α∩force␈α∪and␈α∩stops␈α∪the␈α∩arm␈α∪if␈α∪the␈α∩force
␈↓ ↓H␈↓β␈↓ αHexceeds␈α∩50␈α∩ounces␈α∪(which␈α∩means␈α∩everything␈α∪is␈α∩ok).␈α∩ The␈α∪second␈α∩one␈α∩is␈α∪an␈α∩interrupt
␈↓ ↓H␈↓β␈↓ αHtype␈α⊃condition.␈α⊃ If␈α∩the␈α⊃arm␈α⊃successfully␈α⊃carries␈α∩out␈α⊃the␈α⊃complete␈α⊃MOVE,␈α∩this␈α⊃monitor
␈↓ ↓H␈↓β␈↓ αHis awakened, the message is printed, and control is given to an operator.}
␈↓ ↓H␈↓    END ypickup;
␈↓ ↓H␈↓    bpickup: BEGIN  ␈↓β{pick up the bolt with blue}␈↓
␈↓ ↓H␈↓    grasp(the_arm=BLUE,the_object=bolt,grasp_point=bolt,
␈↓ ↓H␈↓        opening_for_approach=3*CM);
␈↓ ↓H␈↓    END bpickup;
␈↓ ↓H␈↓COEND;
␈↓ ↓H␈↓␈↓ αλ␈↓β{Figure 3 shows the world after the parts have been picked up.}
␈↓ ↓H␈↓MOVE bolt TO beam_hole + VECTOR(0,0,-5.3) WRT beam_hole;
␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α∩BLUE␈α∩arm␈α∩positions␈α⊃itself␈α∩so␈α∩that␈α∩the␈α⊃bolt␈α∩is␈α∩lined␈α∩up␈α⊃with␈α∩the␈α∩beam_hole␈α∩and␈α⊃its
␈↓ ↓H␈↓β␈↓ αλtip is .3 cm away from the outside of the bracket_hole.}
␈↓ ↓H␈↓normal_search(BLUE, .2*CM, 1.6*CM, 60*OZ, 9);
␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α∃pushes␈α∃the␈α∃bolt␈α∃thru␈α∃the␈α∃bracket_hole␈α∃and␈α∃partly␈α∃into␈α∃the␈α∃beam_hole.␈α⊗ If␈α∃control
␈↓ ↓H␈↓β␈↓ αλcontinues past this statement the bolt is assumed to be partly in the hole.}
␈↓ ↓H␈↓MOVE BLUE TO ⊗ * FRAME(ROT(Z,90*DEG),VECTOR(0,0,4))
␈↓ ↓H␈↓    ON FORCE(Z WRT BLUE) > 60*OZ DO STOP BLUE;
␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α∪pushes␈α∀and␈α∪twists␈α∪the␈α∀bolt␈α∪into␈α∪the␈α∀hole.␈α∪ When␈α∪the␈α∀force␈α∪exceeds␈α∪60␈α∀ounces,␈α∪the
␈↓ ↓H␈↓β␈↓ αλbolt␈α∩is␈α⊃assumed␈α∩to␈α⊃be␈α∩completely␈α∩seated␈α⊃in␈α∩the␈α⊃hole.␈α∩ There␈α∩is␈α⊃no␈α∩check␈α⊃to␈α∩make␈α∩sure␈α⊃the
␈↓ ↓H␈↓β␈↓ αλbolt seats properly.}
␈↓ ↓H␈↓COBEGIN
␈↓ ↓H␈↓    parky: BEGIN  ␈↓β{release the bracket and park}␈↓
␈↓ ↓H␈↓    release(the_object=bracket,the_opening=3*CM,the_new_parent=beam);
␈↓ ↓H␈↓    MOVE YELLOW TO YPARK;
␈↓ ↓H␈↓    END parky;
␈↓ ↓H␈↓    parkb: BEGIN  ␈↓β{release the bolt and park}␈↓
␈↓ ↓H␈↓    release(the_arm=BLUE,the_object=bolt,the_opening=3*CM,the_new_parent=beam);
␈↓ ↓H␈↓␈↓ εH␈↓ 
aPage 13

␈↓"∧␈↓ ↓H␈↓    MOVE BLUE TO BPARK;
␈↓ ↓H␈↓    END parkb;
␈↓ ↓H␈↓COEND;
␈↓ ↓H␈↓END whole_task
␈↓ ↓H␈↓Page 14␈↓ εH␈↓ H

































␈↓ ↓H␈↓␈↓ εαFigure    3
␈↓ ↓H␈↓␈↓ ∧CAttach Structures for the Task Example
␈↓ ↓H␈↓␈↓ εH␈↓ 
aPage 15

␈↓"∧␈↓ ↓H␈↓␈↓∧3 CONCLUSIONS␈↓
␈↓"∨␈↓ ↓H␈↓␈↓ αλAL␈α
is␈α
important␈α
for␈α
several␈α
reasons.␈α
 It␈αshows␈α
what␈α
sort␈α
of␈α
considerations␈α
are␈α
necessary␈αfor
␈↓ ↓H␈↓flexible␈α∩control␈α⊃of␈α∩mechanical␈α⊃manipulation.␈α∩ It␈α⊃demonstrates␈α∩the␈α⊃feasibility␈α∩of␈α⊃programmable
␈↓ ↓H␈↓assembly.␈α∪ It␈α∪provides␈α∪a␈α∩research␈α∪tool␈α∪for␈α∪investigation␈α∩of␈α∪new␈α∪modes␈α∪of␈α∪software␈α∩servoing,
␈↓ ↓H␈↓assembly primitives, arm-control primitives, and interactive real-time real-world systems.
␈↓"∨␈↓ ↓H␈↓␈↓ αλAL␈αis␈αcurrently␈αlimited␈αby␈αthe␈αlack␈αof␈αcertain␈αfeatures␈αwhich␈αwould␈αmake␈αit␈αmore␈αcompetent.
␈↓ ↓H␈↓Many␈α
of␈α
these␈α
have␈α
to␈α
do␈α
with␈α
the␈α
fact␈α
that␈α
feedback␈α
is␈α
used␈α
only␈α
in␈α
a␈α
threshold␈α
way;␈α∞either␈α
a
␈↓ ↓H␈↓monitor␈α∞triggers␈α∞or␈α∂it␈α∞does␈α∞not.␈α∂ Fine␈α∞control␈α∞of␈α∂the␈α∞arm␈α∞would␈α∂be␈α∞enhanced␈α∞by␈α∂more␈α∞sensitive
␈↓ ↓H␈↓force-sensing␈αelements␈αon␈αthe␈αhand␈αand␈αa␈αmeans␈αof␈αprogramming␈αaccommodating,␈αnon-threshold
␈↓ ↓H␈↓response␈α∃to␈α∀this␈α∃sensory␈α∀input.␈α∃ Visual␈α∀feedback␈α∃should␈α∀be␈α∃implemented␈α∀to␈α∃provide␈α∀better
␈↓ ↓H␈↓positioning␈αcapability,␈αerror␈α
detection,␈αand␈αerror␈αrecovery.␈α
 Moving␈αassembly␈αlines␈αimply␈α
that␈αAL
␈↓ ↓H␈↓should␈αbe␈α
able␈αto␈α
handle␈αmotions␈α
which␈αit␈αdoes␈α
not␈αcause␈α
directly␈αthrough␈α
manipulation;␈αobjects
␈↓ ↓H␈↓should␈αhave␈αa␈αdynamic␈α
capablility.␈α Collision␈αdetection␈αand␈α
avoidance␈αremain␈αdifficult␈αissues.␈α
 AL
␈↓ ↓H␈↓would␈α∞be␈α
more␈α∞error-free␈α
if␈α∞the␈α∞trajectory␈α
calculator␈α∞could␈α
ensure␈α∞that␈α
the␈α∞arms␈α∞never␈α
interfere
␈↓ ↓H␈↓with each other or with objects in the current world.


␈↓"∨␈↓ ↓H␈↓␈↓∧4 BIBLIOGRAPHY␈↓
␈↓"∨␈↓ ↓H␈↓[Bolles␈α∀and␈α∀Paul]␈α∀R.␈α∀C.␈α∀Bolles,␈α∀R.␈α∪Paul,␈α∀␈↓βThe␈α∀Use␈α∀of␈α∀Sensory␈α∀Feedback␈α∀in␈α∀a␈α∪Programmable
␈↓ ↓H␈↓β␈↓ αHAssembly System␈↓, Stanford Artificial Intelligence Project, Memo No. 220, October 1973.
␈↓"∨␈↓ ↓H␈↓[Finkel]␈α⊂R.␈α⊂Finkel,␈α⊂R.␈α⊂Taylor,␈α⊂R.␈α⊂Bolles,␈α⊃R.␈α⊂Paul,␈α⊂J.␈α⊂Feldman,␈α⊂␈↓βAL,␈α⊂A␈α⊂Programming␈α⊃System␈α⊂for
␈↓ ↓H␈↓β␈↓ αHAutomation␈↓, Stanford Artificial Intelligence Project, Memo No. 243, November 1974.
␈↓"∨␈↓ ↓H␈↓[Inoue]␈α∃H.␈α∃Inoue,␈α⊗"Force␈α∃Feedback␈α∃in␈α∃Precise␈α⊗Assembly␈α∃Tasks,"␈α∃Massachusetts␈α⊗Institute␈α∃of
␈↓ ↓H␈↓␈↓ αHTechnology A. I. Memo No. ***.
␈↓"∨␈↓ ↓H␈↓[Nevins]␈α∃J.␈α∃L.␈α∃Nevins,␈α∃D.␈α∃E.␈α∃Whitney,␈α∃S.␈α∃N.␈α∃Simunovic,␈α∃␈↓βSystem␈α∃Architecture␈α⊗for␈α∃Assembly
␈↓ ↓H␈↓β␈↓ αHMachines␈↓,␈α⊂The␈α⊂Charles␈α⊂Stark␈α⊃Draper␈α⊂Laboratory,␈α⊂Inc.,␈α⊂Memo␈α⊂No.␈α⊃R-764,␈α⊂November
␈↓ ↓H␈↓␈↓ αH1973.
␈↓"∨␈↓ ↓H␈↓[Paul]␈α∞R.␈α∂P.␈α∞Paul,␈α∞␈↓βModelling,Trajectory␈α∂Calculation␈α∞and␈α∞Servoing␈α∂of␈α∞a␈α∞Computer␈α∂Controlled␈α∞Arm␈↓,
␈↓ ↓H␈↓␈↓ αHStanford Artificial Intelligence Project, Memo No. 177, March 1973.
␈↓"∨␈↓ ↓H␈↓[Rosen]␈α∃C␈α∀Rosen,␈α∃␈↓βet.␈α∀al.,␈α∃Exploratory␈α∀Research␈α∃in␈α∀Advanced␈α∃Automation,␈↓␈α∃Stanford␈α∀Research
␈↓ ↓H␈↓␈↓ αHInstitute Report, December 1973.
␈↓ ↓H␈↓Page 16␈↓ εH␈↓ H

␈↓"∧␈↓ ↓H␈↓[Scheinman]␈α~V.␈α~D.␈α≠Scheinman,␈α~␈↓βDesign␈α~of␈α≠a␈α~Computer␈α~Manipulator␈↓,␈α≠Stanford␈α~Artificial
␈↓ ↓H␈↓␈↓ αHIntelligence Project, Memo No. 92, June 1969.
␈↓"∨␈↓ ↓H␈↓[Will]␈α∞Peter␈α∞M.␈α∞Will␈α∞and␈α∞David␈α∂D␈α∞Grossman␈α∞␈↓βAn␈α∞Experimental␈α∞System␈α∞for␈α∂Computer␈α∞Controlled
␈↓ ↓H␈↓β␈↓ αHMechanical␈α⊃Assembly␈↓,␈α⊃IBM␈α⊃Research␈α⊂Report RC 4922,␈α⊃Yorktown␈α⊃Heights,␈α⊃New␈α⊂York.
␈↓ ↓H␈↓␈↓ αHJuly, 1974.